JavaScript Modül Grafiğinde Döngü Kırma: Döngüsel Bağımlılık Çözümü

JavaScript, özünde, ön uç web geliştirmeden arka uç sunucu tarafı betiklemeye ve mobil uygulama geliştirmeye kadar dünya genelinde sayısız uygulama için kullanılan dinamik ve çok yönlü bir dildir. JavaScript projelerinin karmaşıklığı arttıkça, kodun modüller halinde düzenlenmesi sürdürülebilirlik, yeniden kullanılabilirlik ve işbirlikçi geliştirme için hayati önem taşır. Ancak, modüller birbirine bağımlı hale geldiğinde, döngüsel bağımlılıklar olarak bilinen yaygın bir zorluk ortaya çıkar. Bu yazı, JavaScript modül grafiklerindeki döngüsel bağımlılıkların inceliklerine dalmakta, neden sorunlu olabileceklerini açıklamakta ve en önemlisi, bunların etkili bir şekilde çözülmesi için pratik stratejiler sunmaktadır. Hedef kitle, dünyanın farklı yerlerinde çeşitli projeler üzerinde çalışan her deneyim seviyesinden geliştiricilerdir. Bu yazı, en iyi uygulamalara odaklanmakta ve açık, özlü açıklamalar ile uluslararası örnekler sunmaktadır.

JavaScript Modüllerini ve Bağımlılık Grafiklerini Anlama

Döngüsel bağımlılıklara geçmeden önce, JavaScript modülleri ve bir bağımlılık grafiği içinde nasıl etkileşimde bulundukları konusunda sağlam bir anlayış oluşturalım. Modern JavaScript, kod birimlerini tanımlamak ve yönetmek için ES6'da (ECMAScript 2015) tanıtılan ES modül sistemini kullanır. Bu modüller, daha büyük bir kod tabanını daha küçük, daha yönetilebilir ve yeniden kullanılabilir parçalara ayırmamızı sağlar.

ES Modülleri Nedir?

ES Modülleri, JavaScript kodunu paketlemenin ve yeniden kullanmanın standart yoludur. Şunları yapmanızı sağlarlar:

• import ifadesini kullanarak diğer modüllerden belirli işlevselliği içe aktarma.
• export ifadesini kullanarak bir modülden işlevselliği (değişkenler, fonksiyonlar, sınıflar) dışa aktarma, böylece diğer modüllerin kullanımına sunma.

Örnek:

moduleA.js:

            export function myFunction() {
  console.log('Hello from moduleA!');
}

            

              
                Copy
              
            
          

moduleB.js:

            import { myFunction } from './moduleA.js';

function anotherFunction() {
  myFunction();
}

anotherFunction(); // Output: Hello from moduleA!

            

              
                Copy
              
            
          

Bu örnekte, moduleB.js, myFunction fonksiyonunu moduleA.js dosyasından içe aktarır ve kullanır. Bu basit, tek yönlü bir bağımlılıktır.

Bağımlılık Grafikleri: Modül İlişkilerini Görselleştirme

Bir bağımlılık grafiği, bir projedeki farklı modüllerin birbirine nasıl bağımlı olduğunu görsel olarak temsil eder. Grafikteki her düğüm bir modülü, kenarlar (oklar) ise bağımlılıkları (import ifadeleri) gösterir. Örneğin, yukarıdaki örnekte, grafikte iki düğüm (moduleA ve moduleB) ve moduleB'den moduleA'ya doğru bir ok olurdu, bu da moduleB'nin moduleA'ya bağımlı olduğu anlamına gelir. İyi yapılandırılmış bir proje, açık ve döngüsüz bir bağımlılık grafiği hedeflemelidir.

Sorun: Döngüsel Bağımlılıklar

Döngüsel bağımlılık, iki veya daha fazla modülün doğrudan veya dolaylı olarak birbirine bağımlı olması durumunda ortaya çıkar. Bu, bağımlılık grafiğinde bir döngü oluşturur. Örneğin, moduleA, moduleB'den bir şey ithal ederse ve moduleB de moduleA'dan bir şey ithal ederse, döngüsel bir bağımlılığımız var demektir. JavaScript motorları artık bu durumları eski sistemlere göre daha iyi ele alacak şekilde tasarlanmış olsa da, döngüsel bağımlılıklar hala sorunlara neden olabilir.

Döngüsel Bağımlılıklar Neden Sorunludur?

Döngüsel bağımlılıklardan kaynaklanabilecek birkaç sorun vardır:

• Başlatma Sırası: Modüllerin başlatılma sırası kritik hale gelir. Döngüsel bağımlılıklarla, JavaScript motorunun modülleri hangi sırayla yükleyeceğini çözmesi gerekir. Doğru yönetilmezse, bu hatalara veya beklenmedik davranışlara yol açabilir.
• Çalışma Zamanı Hataları: Modül başlatma sırasında, bir modül henüz tam olarak başlatılmamış başka bir modülden dışa aktarılan bir şeyi kullanmaya çalışırsa (çünkü ikinci modül hala yüklenmektedir), hatalarla (undefined gibi) karşılaşabilirsiniz.
• Kod Okunabilirliğinin Azalması: Döngüsel bağımlılıklar, kodunuzu anlamayı ve sürdürmeyi zorlaştırabilir, veri ve mantık akışını kod tabanında izlemeyi güçleştirir. Herhangi bir ülkedeki geliştiriciler, bu tür yapıların hata ayıklamasını daha az karmaşık bir bağımlılık grafiğiyle oluşturulmuş bir kod tabanından önemli ölçüde daha zor bulabilirler.
• Test Edilebilirlik Zorlukları: Döngüsel bağımlılıkları olan modülleri test etmek daha karmaşık hale gelir, çünkü bağımlılıkları taklit etmek (mocking) ve değiştirmek (stubbing) daha zor olabilir.
• Performans Yükü: Bazı durumlarda, döngüsel bağımlılıklar performansı etkileyebilir, özellikle modüller büyükse veya sık kullanılan bir yolda (hot path) kullanılıyorsa.

Döngüsel Bağımlılık Örneği

Döngüsel bir bağımlılığı göstermek için basitleştirilmiş bir örnek oluşturalım. Bu örnek, proje yönetiminin çeşitli yönlerini temsil eden varsayımsal bir senaryo kullanır.

project.js:

            import { taskManager } from './task.js';

export const project = {
  name: 'Project X',
  addTask: (taskName) => {
    taskManager.addTask(taskName, project);
  },
  getTasks: () => {
    return taskManager.getTasksForProject(project);
  }
};

            

              
                Copy
              
            
          

task.js:

            import { project } from './project.js';

export const taskManager = {
  tasks: [],
  addTask: (taskName, project) => {
    taskManager.tasks.push({ name: taskName, project: project.name });
  },
  getTasksForProject: (project) => {
    return taskManager.tasks.filter(task => task.project === project.name);
  }
};

            

              
                Copy
              
            
          

Bu basitleştirilmiş örnekte, hem project.js hem de task.js birbirini içe aktararak döngüsel bir bağımlılık oluşturur. Bu kurulum, başlatma sırasında sorunlara yol açabilir ve proje görev listesiyle veya tam tersi şekilde etkileşime girmeye çalıştığında potansiyel olarak beklenmedik çalışma zamanı davranışlarına neden olabilir. Bu durum özellikle daha büyük sistemlerde geçerlidir.

Döngüsel Bağımlılıkları Çözme: Stratejiler ve Teknikler

Neyse ki, JavaScript'teki döngüsel bağımlılıkları çözebilecek birkaç etkili strateji vardır. Bu teknikler genellikle kodun yeniden düzenlenmesini, modül yapısının yeniden değerlendirilmesini ve modüllerin nasıl etkileşimde bulunduğunun dikkatlice düşünülmesini içerir. Seçilecek yöntem, durumun özelliklerine bağlıdır.

1. Yeniden Düzenleme ve Kodun Yeniden Yapılandırılması

En yaygın ve genellikle en etkili yaklaşım, döngüsel bağımlılığı tamamen ortadan kaldırmak için kodunuzu yeniden yapılandırmayı içerir. Bu, ortak işlevselliği yeni bir modüle taşımayı veya modüllerin nasıl düzenlendiğini yeniden düşünmeyi içerebilir. Yaygın bir başlangıç noktası, projeyi üst düzeyde anlamaktır.

Örnek:

Proje ve görev örneğine geri dönelim ve döngüsel bağımlılığı kaldırmak için yeniden düzenleyelim.

utils.js:

            
export function createTask(taskName, projectName) {
  return { name: taskName, project: projectName };
}

export function filterTasksByProject(tasks, projectName) {
  return tasks.filter(task => task.project === projectName);
}

            

              
                Copy
              
            
          

project.js:

            import { taskManager } from './task.js';
import { filterTasksByProject } from './utils.js';

export const project = {
  name: 'Project X',
  addTask: (taskName) => {
    taskManager.addTask(taskName, project.name);
  },
  getTasks: () => {
    return taskManager.getTasksForProject(project.name);
  }
};

            

              
                Copy
              
            
          

task.js:

            import { createTask, filterTasksByProject } from './utils.js';

export const taskManager = {
  tasks: [],
  addTask: (taskName, projectName) => {
    const newTask = createTask(taskName, projectName);
    taskManager.tasks.push(newTask);
  },
  getTasksForProject: (projectName) => {
    return filterTasksByProject(taskManager.tasks, projectName);
  }
};

            

              
                Copy
              
            
          

Bu yeniden düzenlenmiş versiyonda, genel yardımcı fonksiyonları içeren yeni bir modül, `utils.js` oluşturduk. `taskManager` ve `project` modülleri artık doğrudan birbirine bağımlı değil. Bunun yerine, `utils.js` içindeki yardımcı fonksiyonlara bağımlılar. Örnekte, görev adı proje adına yalnızca bir dize olarak ilişkilendirilmiştir, bu da görev modülünde proje nesnesine olan ihtiyacı ortadan kaldırarak döngüyü kırar.

2. Bağımlılık Enjeksiyonu (Dependency Injection)

Bağımlılık enjeksiyonu, bağımlılıkları bir modüle, genellikle fonksiyon parametreleri veya kurucu argümanları aracılığıyla geçirmeyi içerir. Bu, modüllerin birbirine nasıl bağımlı olduğunu daha açık bir şekilde kontrol etmenizi sağlar. Özellikle karmaşık sistemlerde veya modüllerinizi daha test edilebilir hale getirmek istediğinizde kullanışlıdır. Bağımlılık Enjeksiyonu, yazılım geliştirmede dünya çapında kullanılan, saygın bir tasarım desenidir.

Örnek:

Bir modülün başka bir modülden bir yapılandırma nesnesine erişmesi gereken, ancak ikinci modülün birincisine ihtiyaç duyduğu bir senaryo düşünün. Diyelim ki biri Dubai'de, diğeri New York'ta ve kod tabanını her iki yerde de kullanabilmek istiyoruz. Yapılandırma nesnesini ilk modüle enjekte edebilirsiniz.

config.js:

            
export const defaultConfig = {
  apiUrl: 'https://api.example.com',
  timeout: 5000
};

            

              
                Copy
              
            
          

moduleA.js:

            
import { fetchData } from './moduleB.js';

export function doSomething(config = defaultConfig) {
  console.log('Doing something with config:', config);
  fetchData(config);
}

            

              
                Copy
              
            
          

moduleB.js:

            
export function fetchData(config) {
  console.log('Fetching data from:', config.apiUrl);
}

            

              
                Copy
              
            
          

Config nesnesini doSomething fonksiyonuna enjekte ederek, moduleA'ya olan bağımlılığı kırmış olduk. Bu teknik, modülleri farklı ortamlar (örneğin geliştirme, test, üretim) için yapılandırırken özellikle kullanışlıdır. Bu yöntem dünya çapında kolayca uygulanabilir.

3. İşlevselliğin Bir Alt Kümesini Dışa Aktarma (Kısmi Import/Export)

Bazen, bir modülün işlevselliğinin yalnızca küçük bir kısmı, döngüsel bir bağımlılığa dahil olan başka bir modül tarafından gereklidir. Bu gibi durumlarda, daha odaklanmış bir işlevsellik seti dışa aktarmak için modülleri yeniden düzenleyebilirsiniz. Bu, tam modülün içe aktarılmasını önler ve döngüleri kırmaya yardımcı olur. Bunu, işleri son derece modüler hale getirmek ve gereksiz bağımlılıkları kaldırmak olarak düşünebilirsiniz.

Örnek:

Diyelim ki Modül A, Modül B'den yalnızca bir fonksiyona ve Modül B, Modül A'dan yalnızca bir değişkene ihtiyaç duyuyor. Bu durumda, Modül A'yı yalnızca değişkeni dışa aktaracak ve Modül B'yi yalnızca fonksiyonu içe aktaracak şekilde yeniden düzenlemek döngüselliği çözebilir. Bu, özellikle birden fazla geliştiriciye ve çeşitli beceri setlerine sahip büyük projeler için kullanışlıdır.

moduleA.js:

            
export const myVariable = 'Hello';

            

              
                Copy
              
            
          

moduleB.js:

            
import { myVariable } from './moduleA.js';

function useMyVariable() {
  console.log(myVariable);
}

            

              
                Copy
              
            
          

Modül A, yalnızca gerekli değişkeni Modül B'ye aktarır ve Modül B de bunu içe aktarır. Bu yeniden düzenleme, döngüsel bağımlılığı önler ve kodun yapısını iyileştirir. Bu desen, dünyanın herhangi bir yerindeki hemen hemen her senaryoda işe yarar.

4. Dinamik Import'lar

Dinamik import'lar (import()), modülleri eşzamansız olarak yüklemenin bir yolunu sunar ve bu yaklaşım, döngüsel bağımlılıkları çözmede çok güçlü olabilir. Statik import'ların aksine, dinamik import'lar bir promise döndüren fonksiyon çağrılarıdır. Bu, bir modülün ne zaman ve nasıl yüklendiğini kontrol etmenize olanak tanır ve döngüleri kırmaya yardımcı olabilir. Özellikle bir modülün hemen gerekli olmadığı durumlarda kullanışlıdırlar. Dinamik import'lar ayrıca koşullu import'ları ve modüllerin tembel yüklenmesini (lazy loading) yönetmek için de çok uygundur. Bu tekniğin küresel yazılım geliştirme senaryolarında geniş bir uygulanabilirliği vardır.

Örnek:

Modül A'nın Modül B'den bir şeye ihtiyaç duyduğu ve Modül B'nin de Modül A'dan bir şeye ihtiyaç duyduğu bir senaryoya geri dönelim. Dinamik import'ları kullanmak, Modül A'nın import işlemini ertelemesine olanak tanır.

moduleA.js:

            
export let someValue = 'initial value';

export async function doSomethingWithB() {
  const moduleB = await import('./moduleB.js');
  moduleB.useAValue(someValue);
}

            

              
                Copy
              
            
          

moduleB.js:

            
import { someValue } from './moduleA.js';

export function useAValue(value) {
  console.log('Value from A:', value);
}

            

              
                Copy
              
            
          

Bu yeniden düzenlenmiş örnekte, Modül A, import('./moduleB.js') kullanarak Modül B'yi dinamik olarak içe aktarır. Bu, import işlemi eşzamansız olarak gerçekleştiği için döngüsel bağımlılığı kırar. Dinamik import'ların kullanımı artık endüstri standardıdır ve bu yöntem dünya çapında yaygın olarak desteklenmektedir.

5. Arabulucu/Servis Katmanı Kullanımı

Karmaşık sistemlerde, bir arabulucu veya servis katmanı, modüller arasında merkezi bir iletişim noktası olarak hizmet ederek doğrudan bağımlılıkları azaltabilir. Bu, modülleri birbirinden ayırmaya yardımcı olan bir tasarım desenidir, bu da onları yönetmeyi ve sürdürmeyi kolaylaştırır. Modüller, birbirlerini doğrudan içe aktarmak yerine arabulucu aracılığıyla iletişim kurarlar. Bu yöntem, ekiplerin dünyanın dört bir yanından işbirliği yaptığı küresel ölçekte son derece değerlidir. Arabulucu deseni herhangi bir coğrafyada uygulanabilir.

Örnek:

İki modülün doğrudan bir bağımlılık olmadan bilgi alışverişi yapması gereken bir senaryo düşünelim.

mediator.js:

            
const subscribers = {};

export const mediator = {
  subscribe: (event, callback) => {
    if (!subscribers[event]) {
      subscribers[event] = [];
    }
    subscribers[event].push(callback);
  },
  publish: (event, data) => {
    if (subscribers[event]) {
      subscribers[event].forEach(callback => callback(data));
    }
  }
};

            

              
                Copy
              
            
          

moduleA.js:

            
import { mediator } from './mediator.js';

export function doSomething() {
  mediator.publish('eventFromA', { message: 'Hello from A' });
}

            

              
                Copy
              
            
          

moduleB.js:

            
import { mediator } from './mediator.js';

mediator.subscribe('eventFromA', (data) => {
  console.log('Received event from A:', data);
});

            

              
                Copy
              
            
          

Modül A, arabulucu aracılığıyla bir olay yayınlar ve Modül B aynı olaya abone olarak mesajı alır. Arabulucu, A ve B'nin birbirini içe aktarma ihtiyacını ortadan kaldırır. Bu teknik, mikroservisler, dağıtık sistemler ve uluslararası kullanım için büyük uygulamalar oluştururken özellikle yararlıdır.

6. Gecikmeli Başlatma

Bazen, döngüsel bağımlılıklar belirli modüllerin başlatılmasını geciktirerek yönetilebilir. Bu, bir modülü içe aktarıldığında hemen başlatmak yerine, gerekli bağımlılıklar tamamen yüklenene kadar başlatmayı geciktirdiğiniz anlamına gelir. Bu teknik, geliştiricilerin nerede olduğuna bakılmaksızın her tür proje için genel olarak uygulanabilir.

Örnek:

Diyelim ki döngüsel bağımlılığı olan A ve B adında iki modülünüz var. Modül B'nin başlatılmasını Modül A'dan bir fonksiyon çağırarak geciktirebilirsiniz. Bu, iki modülün aynı anda başlatılmasını önler.

moduleA.js:

            
import * as moduleB from './moduleB.js';

export function init() {
  // Perform initialization steps in module A
  moduleB.initFromA(); // Initialize module B using a function from module A
}

// Call init after moduleA is loaded and its dependencies resolved
init();

            

              
                Copy
              
            
          

moduleB.js:

            
import * as moduleA from './moduleA.js';

export function initFromA() {
  // Module B initialization logic
  console.log('Module B initialized by A');
}

            

              
                Copy
              
            
          

Bu örnekte, moduleB, moduleA'dan sonra başlatılır. Bu, bir modülün diğerinden yalnızca bir alt küme fonksiyon veya veriye ihtiyaç duyduğu ve gecikmeli bir başlatmayı tolere edebileceği durumlarda yardımcı olabilir.

En İyi Uygulamalar ve Dikkat Edilmesi Gerekenler

Döngüsel bağımlılıkları ele almak, sadece bir teknik uygulamaktan daha fazlasıdır; kod kalitesini, sürdürülebilirliği ve ölçeklenebilirliği sağlamak için en iyi uygulamaları benimsemekle ilgilidir. Bu uygulamalar evrensel olarak uygulanabilir.

1. Bağımlılıkları Analiz Edin ve Anlayın

Çözümlere atlamadan önce, ilk adım bağımlılık grafiğini dikkatlice analiz etmektir. Bağımlılık grafiği görselleştirme kütüphaneleri (örneğin, Node.js projeleri için madge) gibi araçlar, modüller arasındaki ilişkileri görselleştirmenize yardımcı olarak döngüsel bağımlılıkları kolayca belirlemenizi sağlar. Bağımlılıkların neden var olduğunu ve her modülün diğerinden hangi veri veya işlevselliği gerektirdiğini anlamak çok önemlidir. Bu analiz, en uygun çözüm stratejisini belirlemenize yardımcı olacaktır.

2. Gevşek Bağlılık (Loose Coupling) için Tasarım Yapın

Gevşek bağlı modüller oluşturmaya çalışın. Bu, modüllerin mümkün olduğunca bağımsız olması ve birbirlerinin iç uygulama detayları hakkında doğrudan bilgi sahibi olmak yerine, iyi tanımlanmış arayüzler (örneğin, fonksiyon çağrıları veya olaylar) aracılığıyla etkileşimde bulunmaları gerektiği anlamına gelir. Gevşek bağlılık, ilk etapta döngüsel bağımlılıklar oluşturma şansını azaltır ve değişiklikleri basitleştirir, çünkü bir modüldeki değişikliklerin diğer modülleri etkileme olasılığı daha düşüktür. Gevşek bağlılık ilkesi, yazılım tasarımında küresel olarak tanınan anahtar bir kavramdır.

3. (Uygulanabilir Olduğunda) Kalıtım Yerine Kompozisyonu Tercih Edin

Nesne yönelimli programlamada (OOP), kalıtım yerine kompozisyonu tercih edin. Kompozisyon, diğer nesneleri birleştirerek nesneler oluşturmayı içerirken, kalıtım mevcut bir sınıfa dayalı yeni bir sınıf oluşturmayı içerir. Kompozisyon genellikle daha esnek ve sürdürülebilir koda yol açar, sıkı bağlılık ve döngüsel bağımlılık olasılığını azaltır. Bu uygulama, özellikle ekiplerin dünya geneline dağıldığı durumlarda ölçeklenebilirlik ve sürdürülebilirlik sağlamaya yardımcı olur.

4. Modüler Kod Yazın

Modüler tasarım ilkelerini kullanın. Her modülün belirli, iyi tanımlanmış bir amacı olmalıdır. Bu, modülleri tek bir işi iyi yapmaya odaklı tutmanıza yardımcı olur ve döngüsel bağımlılıklara daha yatkın olan karmaşık ve aşırı büyük modüllerin oluşturulmasını önler. Modülerlik ilkesi, Amerika Birleşik Devletleri, Avrupa, Asya veya Afrika'da olsun, her tür projede kritiktir.

5. Linter ve Kod Analiz Araçları Kullanın

Geliştirme iş akışınıza linter'ları ve kod analiz araçlarını entegre edin. Bu araçlar, yönetilmesi zor hale gelmeden önce geliştirme sürecinin başlarında potansiyel döngüsel bağımlılıkları belirlemenize yardımcı olabilir. ESLint gibi linter'lar ve kod analiz araçları, ayrıca kodlama standartlarını ve en iyi uygulamaları zorunlu kılarak kod kokularını önlemeye ve kod kalitesini artırmaya yardımcı olabilir. Dünyanın dört bir yanındaki birçok geliştirici, tutarlı stili korumak ve sorunları azaltmak için bu araçları kullanır.

6. Kapsamlı Testler Yapın

Karmaşık bağımlılıklarla uğraşırken bile kodunuzun beklendiği gibi çalıştığından emin olmak için kapsamlı birim testleri, entegrasyon testleri ve uçtan uca testler uygulayın. Testler, döngüsel bağımlılıkların veya herhangi bir çözüm tekniğinin neden olduğu sorunları, üretime etki etmeden önce erken yakalamanıza yardımcı olur. Dünyanın herhangi bir yerindeki herhangi bir kod tabanı için kapsamlı testler yapıldığından emin olun.

7. Kodunuzu Belgeleyin

Özellikle karmaşık bağımlılık yapılarıyla uğraşırken kodunuzu açıkça belgeleyin. Modüllerin nasıl yapılandırıldığını ve birbirleriyle nasıl etkileşimde bulunduğunu açıklayın. İyi dokümantasyon, diğer geliştiricilerin kodunuzu anlamasını kolaylaştırır ve gelecekte döngüsel bağımlılıkların ortaya çıkma riskini azaltabilir. Dokümantasyon, ekip iletişimini geliştirir ve işbirliğini kolaylaştırır ve dünya çapındaki tüm ekipler için geçerlidir.

Sonuç

JavaScript'teki döngüsel bağımlılıklar bir engel olabilir, ancak doğru anlayış ve tekniklerle bunları etkili bir şekilde yönetebilir ve çözebilirsiniz. Bu kılavuzda özetlenen stratejileri izleyerek, geliştiriciler sağlam, sürdürülebilir ve ölçeklenebilir JavaScript uygulamaları oluşturabilirler. Bağımlılıklarınızı analiz etmeyi, gevşek bağlılık için tasarım yapmayı ve bu zorluklardan en başta kaçınmak için en iyi uygulamaları benimsemeyi unutmayın. Modül tasarımı ve bağımlılık yönetiminin temel ilkeleri, dünya çapındaki JavaScript projelerinde kritiktir. İyi organize edilmiş, modüler bir kod tabanı, Dünya'nın herhangi bir yerindeki ekipler ve projeler için başarı için hayati önem taşır. Bu teknikleri özenle kullanarak, JavaScript projelerinizin kontrolünü ele alabilir ve döngüsel bağımlılıkların tuzaklarından kaçınabilirsiniz.